home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 081-090 / amok84 / reqtools_2.1d / glue.lha / Glue / HSPascal.2 / Interface / Utility.pas < prev   
Pascal/Delphi Source File  |  1992-06-24  |  8KB  |  443 lines
  1. Unit Utility;
  2.  
  3. Interface
  4. Uses Exec;
  5.  
  6.  
  7. Type
  8.  
  9. pHook = ^tHook;
  10. tHook    =    Record
  11.                 h_MinNode    :    tMinNode;
  12.                 h_Entry        :    pLongInt;
  13.                 h_SubEntry    :    pLongInt;
  14.                 h_Data        :    Pointer;
  15.             End;
  16.             
  17. Tag    =    LongInt;
  18.  
  19. pTagItem    =    ^tTagItem;
  20. tTagItem    =    Record
  21.                     ti_Tag    :    Tag;
  22.                     ti_Data    :    Longint;
  23.                 End;
  24.                 
  25. Const
  26.  
  27. TAG_DONE            =    0;
  28. TAG_END            =    0;
  29. TAG_IGNORE        =    1;
  30. TAG_MORE            =    2;
  31. TAG_SKIP            =    3;
  32. TAG_USER            =    $80000000;
  33. TAGFILTER_AND    =    0;
  34. TAGFILTER_NOT    =    1;
  35.  
  36.  
  37. Function FindTagItem
  38.          (tagVal: LongInt;
  39.           tagList: Pointer): LongInt;
  40.  
  41. Function GetTagData
  42.          (tagVal,
  43.           defaultVal: LongInt;
  44.           tagList: Pointer): LongInt;
  45.  
  46. Function PackBoolTags
  47.          (initialFlags: LongInt;
  48.           tagList,
  49.           boolMap: Pointer): LongInt;
  50.  
  51. Function NextTagItem (tagListPtr: Pointer): LongInt;
  52. Function FilterTagChanges
  53.          (newTagList,
  54.           oldTagList: Pointer;
  55.           apply: LongInt): LongInt;
  56.  
  57. Function MapTags
  58.          (tagList,
  59.           mapList: Pointer;
  60.           includeMiss: LongInt): LongInt;
  61.  
  62. Function AllocateTagItems (numItems: LongInt): LongInt;
  63. Function CloneTagItems (tagList: Pointer): LongInt;
  64. Function FreeTagItems (tagList: Pointer): LongInt;
  65. Function RefreshTagItemClones
  66.          (cloneList,
  67.           origList: Pointer): LongInt;
  68.  
  69. Function TagInArray
  70.          (tagVal: LongInt;
  71.           tagArray: Pointer): LongInt;
  72.  
  73. Function FilterTagItems
  74.          (tagList,
  75.           filterArray: Pointer;
  76.           logic: LongInt): LongInt;
  77.  
  78. Function CallHookPkt
  79.          (hook,
  80.           object,
  81.           paramPacket: Pointer): LongInt;
  82.  
  83. Function Amiga2Date
  84.          (amigaTime: LongInt;
  85.           date: Pointer): LongInt;
  86.  
  87. Function Date2Amiga (date: Pointer): LongInt;
  88. Function CheckDate (date: Pointer): LongInt;
  89. Function SMult32
  90.          (factor1,
  91.           factor2: LongInt): LongInt;
  92.  
  93. Function UMult32
  94.          (factor1,
  95.           factor2: LongInt): LongInt;
  96.  
  97. Function SDivMod32
  98.          (dividend,
  99.           divisor: LongInt): LongInt;
  100.  
  101. Function UDivMod32
  102.          (dividend,
  103.           divisor: LongInt): LongInt;
  104.  
  105. Function Stricmp
  106.          (string1,
  107.           string2: Pointer): LongInt;
  108.  
  109. Function Strnicmp
  110.          (string1,
  111.           string2: Pointer;
  112.           length: LongInt): LongInt;
  113.  
  114. Function ToUpper (character: LongInt): LongInt;
  115. Function ToLower (character: LongInt): LongInt;
  116.  
  117.  
  118. Var
  119.   UtilityBase: pLibrary;
  120.  
  121.  
  122.  
  123. Implementation
  124. Function FindTagItem
  125.          (tagVal: LongInt;
  126.           tagList: Pointer): LongInt;
  127. XASSEMBLER;
  128. ASM    move.l    a6,-(sp)
  129.     lea    $8(sp),a6
  130.     move.l    (a6)+,a0
  131.     move.l    (a6)+,d0
  132.     move.l    UtilityBase,a6
  133.     jsr    -$1E(a6)
  134.     move.l    d0,$10(sp)
  135.     move.l    (sp)+,a6
  136. END;
  137.  
  138. Function GetTagData
  139.          (tagVal,
  140.           defaultVal: LongInt;
  141.           tagList: Pointer): LongInt;
  142. XASSEMBLER;
  143. ASM    move.l    a6,-(sp)
  144.     lea    $8(sp),a6
  145.     move.l    (a6)+,a0
  146.     move.l    (a6)+,d1
  147.     move.l    (a6)+,d0
  148.     move.l    UtilityBase,a6
  149.     jsr    -$24(a6)
  150.     move.l    d0,$14(sp)
  151.     move.l    (sp)+,a6
  152. END;
  153.  
  154. Function PackBoolTags
  155.          (initialFlags: LongInt;
  156.           tagList,
  157.           boolMap: Pointer): LongInt;
  158. XASSEMBLER;
  159. ASM    move.l    a6,-(sp)
  160.     lea    $8(sp),a6
  161.     move.l    (a6)+,a1
  162.     move.l    (a6)+,a0
  163.     move.l    (a6)+,d0
  164.     move.l    UtilityBase,a6
  165.     jsr    -$2A(a6)
  166.     move.l    d0,$14(sp)
  167.     move.l    (sp)+,a6
  168. END;
  169.  
  170. Function NextTagItem (tagListPtr: Pointer): LongInt;
  171. XASSEMBLER;
  172. ASM    move.l    a6,-(sp)
  173.     move.l    $8(sp),a0
  174.     move.l    UtilityBase,a6
  175.     jsr    -$30(a6)
  176.     move.l    d0,$C(sp)
  177.     move.l    (sp)+,a6
  178. END;
  179.  
  180. Function FilterTagChanges
  181.          (newTagList,
  182.           oldTagList: Pointer;
  183.           apply: LongInt): LongInt;
  184. XASSEMBLER;
  185. ASM    move.l    a6,-(sp)
  186.     lea    $8(sp),a6
  187.     move.l    (a6)+,d0
  188.     move.l    (a6)+,a1
  189.     move.l    (a6)+,a0
  190.     move.l    UtilityBase,a6
  191.     jsr    -$36(a6)
  192.     move.l    d0,$14(sp)
  193.     move.l    (sp)+,a6
  194. END;
  195.  
  196. Function MapTags
  197.          (tagList,
  198.           mapList: Pointer;
  199.           includeMiss: LongInt): LongInt;
  200. XASSEMBLER;
  201. ASM    move.l    a6,-(sp)
  202.     lea    $8(sp),a6
  203.     move.l    (a6)+,d0
  204.     move.l    (a6)+,a1
  205.     move.l    (a6)+,a0
  206.     move.l    UtilityBase,a6
  207.     jsr    -$3C(a6)
  208.     move.l    d0,$14(sp)
  209.     move.l    (sp)+,a6
  210. END;
  211.  
  212. Function AllocateTagItems (numItems: LongInt): LongInt;
  213. XASSEMBLER;
  214. ASM    move.l    a6,-(sp)
  215.     move.l    $8(sp),d0
  216.     move.l    UtilityBase,a6
  217.     jsr    -$42(a6)
  218.     move.l    d0,$C(sp)
  219.     move.l    (sp)+,a6
  220. END;
  221.  
  222. Function CloneTagItems (tagList: Pointer): LongInt;
  223. XASSEMBLER;
  224. ASM    move.l    a6,-(sp)
  225.     move.l    $8(sp),a0
  226.     move.l    UtilityBase,a6
  227.     jsr    -$48(a6)
  228.     move.l    d0,$C(sp)
  229.     move.l    (sp)+,a6
  230. END;
  231.  
  232. Function FreeTagItems (tagList: Pointer): LongInt;
  233. XASSEMBLER;
  234. ASM    move.l    a6,-(sp)
  235.     move.l    $8(sp),a0
  236.     move.l    UtilityBase,a6
  237.     jsr    -$4E(a6)
  238.     move.l    d0,$C(sp)
  239.     move.l    (sp)+,a6
  240. END;
  241.  
  242. Function RefreshTagItemClones
  243.          (cloneList,
  244.           origList: Pointer): LongInt;
  245. XASSEMBLER;
  246. ASM    move.l    a6,-(sp)
  247.     lea    $8(sp),a6
  248.     move.l    (a6)+,a1
  249.     move.l    (a6)+,a0
  250.     move.l    UtilityBase,a6
  251.     jsr    -$54(a6)
  252.     move.l    d0,$10(sp)
  253.     move.l    (sp)+,a6
  254. END;
  255.  
  256. Function TagInArray
  257.          (tagVal: LongInt;
  258.           tagArray: Pointer): LongInt;
  259. XASSEMBLER;
  260. ASM    move.l    a6,-(sp)
  261.     lea    $8(sp),a6
  262.     move.l    (a6)+,a0
  263.     move.l    (a6)+,d0
  264.     move.l    UtilityBase,a6
  265.     jsr    -$5A(a6)
  266.     move.l    d0,$10(sp)
  267.     move.l    (sp)+,a6
  268. END;
  269.  
  270. Function FilterTagItems
  271.          (tagList,
  272.           filterArray: Pointer;
  273.           logic: LongInt): LongInt;
  274. XASSEMBLER;
  275. ASM    move.l    a6,-(sp)
  276.     lea    $8(sp),a6
  277.     move.l    (a6)+,d0
  278.     move.l    (a6)+,a1
  279.     move.l    (a6)+,a0
  280.     move.l    UtilityBase,a6
  281.     jsr    -$60(a6)
  282.     move.l    d0,$14(sp)
  283.     move.l    (sp)+,a6
  284. END;
  285.  
  286. Function CallHookPkt
  287.          (hook,
  288.           object,
  289.           paramPacket: Pointer): LongInt;
  290. XASSEMBLER;
  291. ASM    movem.l    a2/a6,-(sp)
  292.     lea    $C(sp),a6
  293.     move.l    (a6)+,a1
  294.     move.l    (a6)+,a2
  295.     move.l    (a6)+,a0
  296.     move.l    UtilityBase,a6
  297.     jsr    -$66(a6)
  298.     move.l    d0,$18(sp)
  299.     movem.l    (sp)+,a2/a6
  300. END;
  301.  
  302. Function Amiga2Date
  303.          (amigaTime: LongInt;
  304.           date: Pointer): LongInt;
  305. XASSEMBLER;
  306. ASM    move.l    a6,-(sp)
  307.     lea    $8(sp),a6
  308.     move.l    (a6)+,a0
  309.     move.l    (a6)+,d0
  310.     move.l    UtilityBase,a6
  311.     jsr    -$78(a6)
  312.     move.l    d0,$10(sp)
  313.     move.l    (sp)+,a6
  314. END;
  315.  
  316. Function Date2Amiga (date: Pointer): LongInt;
  317. XASSEMBLER;
  318. ASM    move.l    a6,-(sp)
  319.     move.l    $8(sp),a0
  320.     move.l    UtilityBase,a6
  321.     jsr    -$7E(a6)
  322.     move.l    d0,$C(sp)
  323.     move.l    (sp)+,a6
  324. END;
  325.  
  326. Function CheckDate (date: Pointer): LongInt;
  327. XASSEMBLER;
  328. ASM    move.l    a6,-(sp)
  329.     move.l    $8(sp),a0
  330.     move.l    UtilityBase,a6
  331.     jsr    -$84(a6)
  332.     move.l    d0,$C(sp)
  333.     move.l    (sp)+,a6
  334. END;
  335.  
  336. Function SMult32
  337.          (factor1,
  338.           factor2: LongInt): LongInt;
  339. XASSEMBLER;
  340. ASM    move.l    a6,-(sp)
  341.     lea    $8(sp),a6
  342.     move.l    (a6)+,d1
  343.     move.l    (a6)+,d0
  344.     move.l    UtilityBase,a6
  345.     jsr    -$8A(a6)
  346.     move.l    d0,$10(sp)
  347.     move.l    (sp)+,a6
  348. END;
  349.  
  350. Function UMult32
  351.          (factor1,
  352.           factor2: LongInt): LongInt;
  353. XASSEMBLER;
  354. ASM    move.l    a6,-(sp)
  355.     lea    $8(sp),a6
  356.     move.l    (a6)+,d1
  357.     move.l    (a6)+,d0
  358.     move.l    UtilityBase,a6
  359.     jsr    -$90(a6)
  360.     move.l    d0,$10(sp)
  361.     move.l    (sp)+,a6
  362. END;
  363.  
  364. Function SDivMod32
  365.          (dividend,
  366.           divisor: LongInt): LongInt;
  367. XASSEMBLER;
  368. ASM    move.l    a6,-(sp)
  369.     lea    $8(sp),a6
  370.     move.l    (a6)+,d1
  371.     move.l    (a6)+,d0
  372.     move.l    UtilityBase,a6
  373.     jsr    -$96(a6)
  374.     move.l    d0,$10(sp)
  375.     move.l    (sp)+,a6
  376. END;
  377.  
  378. Function UDivMod32
  379.          (dividend,
  380.           divisor: LongInt): LongInt;
  381. XASSEMBLER;
  382. ASM    move.l    a6,-(sp)
  383.     lea    $8(sp),a6
  384.     move.l    (a6)+,d1
  385.     move.l    (a6)+,d0
  386.     move.l    UtilityBase,a6
  387.     jsr    -$9C(a6)
  388.     move.l    d0,$10(sp)
  389.     move.l    (sp)+,a6
  390. END;
  391.  
  392. Function Stricmp
  393.          (string1,
  394.           string2: Pointer): LongInt;
  395. XASSEMBLER;
  396. ASM    move.l    a6,-(sp)
  397.     lea    $8(sp),a6
  398.     move.l    (a6)+,a1
  399.     move.l    (a6)+,a0
  400.     move.l    UtilityBase,a6
  401.     jsr    -$A2(a6)
  402.     move.l    d0,$10(sp)
  403.     move.l    (sp)+,a6
  404. END;
  405.  
  406. Function Strnicmp
  407.          (string1,
  408.           string2: Pointer;
  409.           length: LongInt): LongInt;
  410. XASSEMBLER;
  411. ASM    move.l    a6,-(sp)
  412.     lea    $8(sp),a6
  413.     move.l    (a6)+,d0
  414.     move.l    (a6)+,a1
  415.     move.l    (a6)+,a0
  416.     move.l    UtilityBase,a6
  417.     jsr    -$A8(a6)
  418.     move.l    d0,$14(sp)
  419.     move.l    (sp)+,a6
  420. END;
  421.  
  422. Function ToUpper (character: LongInt): LongInt;
  423. XASSEMBLER;
  424. ASM    move.l    a6,-(sp)
  425.     move.l    $8(sp),d0
  426.     move.l    UtilityBase,a6
  427.     jsr    -$AE(a6)
  428.     move.l    d0,$C(sp)
  429.     move.l    (sp)+,a6
  430. END;
  431.  
  432. Function ToLower (character: LongInt): LongInt;
  433. XASSEMBLER;
  434. ASM    move.l    a6,-(sp)
  435.     move.l    $8(sp),d0
  436.     move.l    UtilityBase,a6
  437.     jsr    -$B4(a6)
  438.     move.l    d0,$C(sp)
  439.     move.l    (sp)+,a6
  440. END;
  441.  
  442. End.
  443.